Termination w.r.t. Q proof of TRS/Rubioselsort.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MIN₁(cons₂(N, cons₂(M, L))) -> LE₂(N, M)
IFMIN₂(true, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(N, L))
IFREPL₄(false, N, M, cons₂(K, L)) -> REPLACE₃(N, M, L)
REPLACE₃(N, M, cons₂(K, L)) -> EQ₂(N, K)
REPLACE₃(N, M, cons₂(K, L)) -> IFREPL₄(eq₂(N, K), N, M, cons₂(K, L))
IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))
IFMIN₂(false, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(M, L))
SELSORT₁(cons₂(N, L)) -> EQ₂(N, min₁(cons₂(N, L)))
EQ₂(s₁(X), s₁(Y)) -> EQ₂(X, Y)
SELSORT₁(cons₂(N, L)) -> MIN₁(cons₂(N, L))
IFSELSORT₂(false, cons₂(N, L)) -> REPLACE₃(min₁(cons₂(N, L)), N, L)
LE₂(s₁(X), s₁(Y)) -> LE₂(X, Y)
IFSELSORT₂(true, cons₂(N, L)) -> SELSORT₁(L)
MIN₁(cons₂(N, cons₂(M, L))) -> IFMIN₂(le₂(N, M), cons₂(N, cons₂(M, L)))
IFSELSORT₂(false, cons₂(N, L)) -> MIN₁(cons₂(N, L))
SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MIN₁(cons₂(N, cons₂(M, L))) -> LE₂(N, M)
IFMIN₂(true, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(N, L))
IFREPL₄(false, N, M, cons₂(K, L)) -> REPLACE₃(N, M, L)
REPLACE₃(N, M, cons₂(K, L)) -> EQ₂(N, K)
REPLACE₃(N, M, cons₂(K, L)) -> IFREPL₄(eq₂(N, K), N, M, cons₂(K, L))
IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))
IFMIN₂(false, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(M, L))
SELSORT₁(cons₂(N, L)) -> EQ₂(N, min₁(cons₂(N, L)))
EQ₂(s₁(X), s₁(Y)) -> EQ₂(X, Y)
SELSORT₁(cons₂(N, L)) -> MIN₁(cons₂(N, L))
IFSELSORT₂(false, cons₂(N, L)) -> REPLACE₃(min₁(cons₂(N, L)), N, L)
LE₂(s₁(X), s₁(Y)) -> LE₂(X, Y)
IFSELSORT₂(true, cons₂(N, L)) -> SELSORT₁(L)
MIN₁(cons₂(N, cons₂(M, L))) -> IFMIN₂(le₂(N, M), cons₂(N, cons₂(M, L)))
IFSELSORT₂(false, cons₂(N, L)) -> MIN₁(cons₂(N, L))
SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 6 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE₂(s₁(X), s₁(Y)) -> LE₂(X, Y)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LE₂(s₁(X), s₁(Y)) -> LE₂(X, Y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(LE₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(s₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IFMIN₂(false, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(M, L))
IFMIN₂(true, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(N, L))
MIN₁(cons₂(N, cons₂(M, L))) -> IFMIN₂(le₂(N, M), cons₂(N, cons₂(M, L)))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MIN₁(cons₂(N, cons₂(M, L))) -> IFMIN₂(le₂(N, M), cons₂(N, cons₂(M, L)))

The remaining pairs can at least be oriented weakly.

IFMIN₂(false, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(M, L))
IFMIN₂(true, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(N, L))

Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(IFMIN₂(x₁, x₂)) = x₂
POL(MIN₁(x₁)) = 1 + x₁
POL(cons₂(x₁, x₂)) = 1 + x₂
POL(false) = 0
POL(le₂(x₁, x₂)) = 0
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IFMIN₂(false, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(M, L))
IFMIN₂(true, cons₂(N, cons₂(M, L))) -> MIN₁(cons₂(N, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(s₁(X), s₁(Y)) -> EQ₂(X, Y)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(s₁(X), s₁(Y)) -> EQ₂(X, Y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(EQ₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(s₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IFREPL₄(false, N, M, cons₂(K, L)) -> REPLACE₃(N, M, L)
REPLACE₃(N, M, cons₂(K, L)) -> IFREPL₄(eq₂(N, K), N, M, cons₂(K, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

IFREPL₄(false, N, M, cons₂(K, L)) -> REPLACE₃(N, M, L)
REPLACE₃(N, M, cons₂(K, L)) -> IFREPL₄(eq₂(N, K), N, M, cons₂(K, L))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(IFREPL₄(x₁, x₂, x₃, x₄)) = 2·x₂ + 3·x₄
POL(REPLACE₃(x₁, x₂, x₃)) = 3 + 2·x₁ + 3·x₃
POL(cons₂(x₁, x₂)) = 3 + x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

IFSELSORT₂(true, cons₂(N, L)) -> SELSORT₁(L)
IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))
SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

IFSELSORT₂(true, cons₂(N, L)) -> SELSORT₁(L)

The remaining pairs can at least be oriented weakly.

IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))
SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))

Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(IFSELSORT₂(x₁, x₂)) = x₂
POL(SELSORT₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 2 + x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(ifmin₂(x₁, x₂)) = 1
POL(ifrepl₄(x₁, x₂, x₃, x₄)) = 2·x₂ + x₄
POL(le₂(x₁, x₂)) = 2
POL(min₁(x₁)) = 1
POL(nil) = 2
POL(replace₃(x₁, x₂, x₃)) = 2·x₁ + x₃
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented:

ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
replace₃(N, M, nil) -> nil

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SELSORT₁(cons₂(N, L)) -> IFSELSORT₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
IFSELSORT₂(false, cons₂(N, L)) -> SELSORT₁(replace₃(min₁(cons₂(N, L)), N, L))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0) = 1
POL(IFSELSORT₂(x₁, x₂)) = 3·x₂
POL(SELSORT₁(x₁)) = 1 + 3·x₁
POL(cons₂(x₁, x₂)) = 2 + 3·x₁ + x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(ifmin₂(x₁, x₂)) = 1 + x₂
POL(ifrepl₄(x₁, x₂, x₃, x₄)) = 3·x₃ + x₄
POL(le₂(x₁, x₂)) = 2 + x₁ + x₂
POL(min₁(x₁)) = 3 + x₁
POL(nil) = 3
POL(replace₃(x₁, x₂, x₃)) = 3·x₂ + x₃
POL(s₁(x₁)) = 1 + 3·x₁
POL(true) = 0

The following usable rules [14] were oriented:

ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
replace₃(N, M, nil) -> nil

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(Y)) -> false
eq₂(s₁(X), 0) -> false
eq₂(s₁(X), s₁(Y)) -> eq₂(X, Y)
le₂(0, Y) -> true
le₂(s₁(X), 0) -> false
le₂(s₁(X), s₁(Y)) -> le₂(X, Y)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(N), nil)) -> s₁(N)
min₁(cons₂(N, cons₂(M, L))) -> ifmin₂(le₂(N, M), cons₂(N, cons₂(M, L)))
ifmin₂(true, cons₂(N, cons₂(M, L))) -> min₁(cons₂(N, L))
ifmin₂(false, cons₂(N, cons₂(M, L))) -> min₁(cons₂(M, L))
replace₃(N, M, nil) -> nil
replace₃(N, M, cons₂(K, L)) -> ifrepl₄(eq₂(N, K), N, M, cons₂(K, L))
ifrepl₄(true, N, M, cons₂(K, L)) -> cons₂(M, L)
ifrepl₄(false, N, M, cons₂(K, L)) -> cons₂(K, replace₃(N, M, L))
selsort₁(nil) -> nil
selsort₁(cons₂(N, L)) -> ifselsort₂(eq₂(N, min₁(cons₂(N, L))), cons₂(N, L))
ifselsort₂(true, cons₂(N, L)) -> cons₂(N, selsort₁(L))
ifselsort₂(false, cons₂(N, L)) -> cons₂(min₁(cons₂(N, L)), selsort₁(replace₃(min₁(cons₂(N, L)), N, L)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.